WebAssembly์ ๋ค์ค ๊ฐ ๋ฐํ ๊ธฐ๋ฅ๊ณผ ์ต์ ํ๋ฅผ ์ดํด๋ณด๊ณ , ์ ์ธ๊ณ ์ ํ๋ฆฌ์ผ์ด์ ์ ํจ์ ์ธํฐํ์ด์ค์ ์ฑ๋ฅ์ ํฅ์์ํต๋๋ค.
WebAssembly ๋ค์ค ๊ฐ ๋ฐํ ์ต์ ํ: ํจ์ ์ธํฐํ์ด์ค ๊ฐ์
WebAssembly(Wasm)๋ ํ๋ ์น๊ณผ ๊ทธ ์ด์์ ์ํ ์ค์ํ ๊ธฐ์ ๋ก ๋น ๋ฅด๊ฒ ์๋ฆฌ ์ก์์ต๋๋ค. ๋ค์ํ ํ๋ซํผ์์ ํจ์จ์ ์ผ๋ก ์ฝ๋๋ฅผ ์คํํ ์ ์๋ ๊ธฐ๋ฅ์ ์ ์ธ๊ณ ๊ฐ๋ฐ์๋ค์๊ฒ ์๋ก์ด ๊ฐ๋ฅ์ฑ์ ์ด์ด์ฃผ์์ต๋๋ค. Wasm ์งํ์ ํต์ฌ ์ธก๋ฉด ์ค ํ๋๋ ํจ์ ์ธํฐํ์ด์ค์ ์ต์ ํ์ด๋ฉฐ, ์ด ๋ถ์ผ์์ ์ค์ํ ๋ฐ์ ์ ๋ค์ค ๊ฐ ๋ฐํ ๊ธฐ๋ฅ์ ๋๋ค. ์ด ๋ธ๋ก๊ทธ ๊ฒ์๋ฌผ์์๋ ์ด ๊ธฐ๋ฅ์ ๋ํด ์์ธํ ์์๋ณด๊ณ , ์ ์ธ๊ณ ๊ฐ๋ฐ์์๊ฒ ๋ฏธ์น๋ ์ํฅ๊ณผ ์ด์ ์ ์ดํด๋ณด๊ณ , ๋ณด๋ค ํจ์จ์ ์ด๊ณ ์ฑ๋ฅ์ด ๋ฐ์ด๋ ์ ํ๋ฆฌ์ผ์ด์ ์ ๋ง๋๋ ๋ฐ ์ค์ ์ ๋ ๊ฒ์ ๋๋ค.
WebAssembly ๋ฐ ๊ทธ ์ญํ ์ดํด
WebAssembly๋ ์คํ ๊ธฐ๋ฐ ๊ฐ์ ๋จธ์ ์ ์ํด ์ค๊ณ๋ ๋ฐ์ด๋๋ฆฌ ๋ช ๋ น์ด ํ์์ ๋๋ค. ์ปดํ์ผ์ ์ํ ํด๋์ฉ ๋์์ผ๋ก ์๋๋์ด ์น ๋ฐ ๊ธฐํ ํ๊ฒฝ์ ๋ฐฐํฌํ ์ ์์ต๋๋ค. Wasm์ ๋น ๋ฅด๊ณ ํจ์จ์ ์ด๋ฉฐ ์์ ํ ์คํ ํ๊ฒฝ์ ์ ๊ณตํ์ฌ ๊ธฐ๋ณธ ์๋์ ๊ฐ๊น๊ฒ ์คํํ๋ ๊ฒ์ ๋ชฉํ๋ก ํฉ๋๋ค. ๋ฐ๋ผ์ ๋ํํ ์น ์ ํ๋ฆฌ์ผ์ด์ ์์ ์๋ฒ ์ธก ํ๋ก๊ทธ๋จ, ์ฌ์ง์ด ์๋ฒ ๋๋ ์์คํ ์ ์ด๋ฅด๊ธฐ๊น์ง ๊ด๋ฒ์ํ ์ ํ๋ฆฌ์ผ์ด์ ์ ์ด์์ ์ ๋๋ค. ๊ด๋ฒ์ํ ์ฑํ์ ์ ์์ฑ๊ณผ ํจ์จ์ฑ์ ๊ฐ์กฐํฉ๋๋ค.
Wasm์ ํต์ฌ ์ค๊ณ ์์น์ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
- ์ด์์ฑ: ๋ค์ํ ํ๋ซํผ ๋ฐ ๋ธ๋ผ์ฐ์ ์์ ์คํํฉ๋๋ค.
- ํจ์จ์ฑ: ๊ธฐ๋ณธ ์ฝ๋์ ๊ฐ๊น์ด ์ฑ๋ฅ์ ์ ๊ณตํฉ๋๋ค.
- ๋ณด์: ์์ ํ๊ณ ์์ ํ ์คํ ํ๊ฒฝ.
- ๊ฐ๋ฐฉํ ํ์ค: ์ง์์ ์ธ ๋ฐ์ ์ ํตํด ์ปค๋ฎค๋ํฐ์์ ์ ์ง ๊ด๋ฆฌํฉ๋๋ค.
Wasm์์ ํจ์ ์ธํฐํ์ด์ค์ ์ค์์ฑ
ํจ์ ์ธํฐํ์ด์ค๋ ํ๋ก๊ทธ๋จ์ ์ฌ๋ฌ ๋ถ๋ถ์ด ์ํธ ์์ฉํ ์ ์๋๋ก ํ๋ ๊ฒ์ดํธ์จ์ด์ ๋๋ค. ํ๋ก๊ทธ๋จ ํจ์จ์ฑ๊ณผ ์ค๊ณ์ ์ค์ํ ๋ฐ์ดํฐ๊ฐ ํจ์ ์ํ์ผ๋ก ์ ๋ฌ๋๋ ๋ฐฉ์์ ์ ์ํฉ๋๋ค. Wasm์ ์ปจํ ์คํธ์์ ํจ์ ์ธํฐํ์ด์ค๋ ์ ์ฒด ์ฑ๋ฅ์ ์ง์ ์ ์ธ ์ํฅ์ ๋ฏธ์น๊ธฐ ๋๋ฌธ์ ๋งค์ฐ ์ค์ํฉ๋๋ค. ์ด๋ฌํ ์ธํฐํ์ด์ค๋ฅผ ์ต์ ํํ๋ ๊ฒ์ ์ฑ๋ฅ ํฅ์์ ์ํ ์ฃผ์ ๋ชฉํ์ด๋ฉฐ, ๋ณด๋ค ํจ์จ์ ์ธ ๋ฐ์ดํฐ ํ๋ฆ๊ณผ ๊ถ๊ทน์ ์ผ๋ก ๋ณด๋ค ์๋ต์ฑ์ด ๋ฐ์ด๋ ์ ํ๋ฆฌ์ผ์ด์ ์ ๊ฐ๋ฅํ๊ฒ ํฉ๋๋ค.
๊ธฐ์กด์ ์ ํ ์ฌํญ์ ๊ณ ๋ คํ์ญ์์ค. ๋ค์ค ๊ฐ ๋ฐํ ์ด์ ์๋ Wasm์ ํจ์๊ฐ ์ผ๋ฐ์ ์ผ๋ก ๋จ์ผ ๊ฐ์ ๋ฐํํ์ต๋๋ค. ํจ์๊ฐ ์ฌ๋ฌ ๊ฐ์ ๋ฐํํด์ผ ํ๋ ๊ฒฝ์ฐ ํ๋ก๊ทธ๋๋จธ๋ ๋ค์๊ณผ ๊ฐ์ ํด๊ฒฐ ๋ฐฉ๋ฒ์ ์ฌ์ฉํด์ผ ํ์ต๋๋ค.
- ๊ตฌ์กฐ์ฒด ๋๋ ๊ฐ์ฒด ๋ฐํ: ์ฌ๊ธฐ์๋ ์ฌ๋ฌ ๋ฐํ ๊ฐ์ ๋ณด์ ํ๊ธฐ ์ํด ๋ณตํฉ ๋ฐ์ดํฐ ๊ตฌ์กฐ๋ฅผ ์์ฑํ๋ ์์ ์ด ํฌํจ๋๋ฉฐ, ์ค๋ฒํค๋๋ฅผ ์ถ๊ฐํ๋ ํ ๋น, ๋ณต์ฌ ๋ฐ ํ ๋น ํด์ ์์ ์ด ํ์ํฉ๋๋ค.
- out ๋งค๊ฐ๋ณ์ ์ฌ์ฉ: ๋งค๊ฐ๋ณ์๋ก ์ ๋ฌ๋ ๋ฐ์ดํฐ๋ฅผ ์์ ํ๊ธฐ ์ํด ๊ฐ๋ณ ํฌ์ธํฐ๋ฅผ ํจ์์ ์ ๋ฌํฉ๋๋ค. ์ด๋ ๊ฒ ํ๋ฉด ํจ์ ์๋ช ์ด ๋ณต์กํด์ง๊ณ ์ ์ฌ์ ์ธ ๋ฉ๋ชจ๋ฆฌ ๊ด๋ฆฌ ๋ฌธ์ ๊ฐ ๋ฐ์ํ ์ ์์ต๋๋ค.
๋ค์ค ๊ฐ ๋ฐํ: ๊ฒ์ ์ฒด์ธ์
Wasm์ ๋ค์ค ๊ฐ ๋ฐํ ๊ธฐ๋ฅ์ ํจ์ ์ธํฐํ์ด์ค์ ํ๋ช ์ ์ผ์ผํต๋๋ค. Wasm ํจ์๊ฐ ํด๊ฒฐ ๋ฐฉ๋ฒ์ ์์กดํ์ง ์๊ณ ์ฌ๋ฌ ๊ฐ์ ์ง์ ๋ฐํํ ์ ์์ต๋๋ค. ๋ฐ๋ผ์ ํนํ ์ฌ๋ฌ ๊ฐ์ ๊ณ์ฐ์ ์ผ๋ถ๋ก ๋ฐํํด์ผ ํ๋ ๊ฒฝ์ฐ Wasm ๋ชจ๋์ ํจ์จ์ฑ๊ณผ ์ฑ๋ฅ์ด ํฌ๊ฒ ํฅ์๋ฉ๋๋ค. ์ฌ๋ฌ ๊ฐ์ด ๋ ์ง์คํฐ๋ฅผ ํตํด ํจ์จ์ ์ผ๋ก ๋ฐํ๋๋ ๊ธฐ๋ณธ ์ฝ๋ ๋์์ ๋ฐ์ํฉ๋๋ค.
์๋ ๋ฐฉ์: ๋ค์ค ๊ฐ ๋ฐํ์ ์ฌ์ฉํ๋ฉด Wasm ๋ฐํ์์ด ๋ ์ง์คํฐ ๋๋ ๋ณด๋ค ํจ์จ์ ์ธ ์คํ ๊ธฐ๋ฐ ๋ฉ์ปค๋์ฆ์ ์ฌ์ฉํ์ฌ ์ฌ๋ฌ ๊ฐ์ ์ง์ ๋ฐํํ ์ ์์ต๋๋ค. ์ด๋ ๊ฒ ํ๋ฉด ๋ณตํฉ ๋ฐ์ดํฐ ๊ตฌ์กฐ๋ฅผ ๋ง๋ค๊ณ ๊ด๋ฆฌํ๊ฑฐ๋ ๊ฐ๋ณ ํฌ์ธํฐ๋ฅผ ์ฌ์ฉํ๋ ๊ฒ๊ณผ ๊ด๋ จ๋ ์ค๋ฒํค๋๊ฐ ๋ฐฉ์ง๋ฉ๋๋ค.
์ด์ :
- ํฅ์๋ ์ฑ๋ฅ: ๋ฉ๋ชจ๋ฆฌ ํ ๋น ๋ฐ ํ ๋น ํด์ ์์ ์ด ์ค์ด๋ค์ด ์คํ ์๋๊ฐ ๋นจ๋ผ์ง๋๋ค.
- ๊ฐ์ํ๋ ์ฝ๋: ๋ ๊น๋ํ ํจ์ ์๋ช ๊ณผ ๋ณต์ก์ฑ ๊ฐ์.
- ๋ ๋์ ์ํธ ์ด์ฉ์ฑ: ๋ณต์กํ ๋ง์ฌ๋ง ์์ ์์ด๋ ์ฌ๋ฌ ๊ฐ์ ๋ค์ ์ ๋ฌํ ์ ์์ผ๋ฏ๋ก ํธ์คํธ ํ๊ฒฝ๊ณผ์ ํตํฉ์ด ๊ฐ์ํ๋ฉ๋๋ค.
- ์ต์ ํ๋ ์ปดํ์ผ๋ฌ ์ง์: Emscripten ๋ฑ๊ณผ ๊ฐ์ ์ปดํ์ผ๋ฌ๋ ๋ค์ค ๊ฐ ๋ฐํ ์๋๋ฆฌ์ค์ ๋ํด ์ต์ ํ๋ ์ฝ๋๋ฅผ ๋ณด๋ค ํจ๊ณผ์ ์ผ๋ก ์์ฑํ ์ ์์ต๋๋ค.
์ฌ์ธต ๋ถ์: ๊ธฐ์ ์ ์ธก๋ฉด ๋ฐ ๊ตฌํ
Wasm ์์ค์์์ ๊ตฌํ: Wasm ๋ฐ์ด๋๋ฆฌ ํ์๊ณผ ๊ฐ์ ๋จธ์ ์ค๊ณ์๋ ๋ค์ค ๊ฐ ๋ฐํ์ ์ง์ํ๋ ํน์ ๊ธฐ๋ฅ์ด ํฌํจ๋์ด ์์ต๋๋ค. ๋ชจ๋์ ์ ํ ์น์ ์ ์๋ ํจ์ ์ ํ ์๋ช ์ ๊ตฌ์กฐ๋ฅผ ํตํด ์ฌ๋ฌ ๋ฐํ ์ ํ์ ์ ์ํ ์ ์์ต๋๋ค. ๋ฐ๋ผ์ Wasm ์ธํฐํ๋ฆฌํฐ ๋๋ ์ปดํ์ผ๋ฌ๋ ์ด์ ์ ์ค๋ช ํ ํด๊ฒฐ ๋ฐฉ๋ฒ ์์ด๋ ๋ฐํ ๊ฐ์ ์ง์ ํจ๊ณผ์ ์ผ๋ก ๊ด๋ฆฌํ ์ ์์ต๋๋ค.
์ปดํ์ผ๋ฌ ์ง์: Emscripten(C/C++์ Wasm์ผ๋ก ์ปดํ์ผํ๊ธฐ ์ํ), Rust(Wasm ๋์์ ํตํด) ๋ฐ AssemblyScript(Wasm์ผ๋ก ์ปดํ์ผ๋๋ TypeScript์ ์ ์ฌํ ์ธ์ด)์ ๊ฐ์ ์ปดํ์ผ๋ฌ๋ ๋ค์ค ๊ฐ ๋ฐํ์ ๋ํ ํตํฉ ์ง์์ ์ ๊ณตํฉ๋๋ค. ์ด๋ฌํ ์ปดํ์ผ๋ฌ๋ ์ธ์ด ๊ตฌ๋ฌธ์ ์ต์ ํ๋ Wasm ๋ช ๋ น์ด๋ก ์๋ ๋ณํํฉ๋๋ค.
์: Emscripten์ ์ฌ์ฉํ๋ C/C++
๋ ์ซ์์ ํฉ๊ณผ ์ฐจ๋ฅผ ๊ณ์ฐํ๋ C/C++ ํจ์๋ฅผ ์๊ฐํด ๋ณด์ญ์์ค.
#include <stdio.h>
//Function returning multiple values as a struct (before multi-value return)
struct SumDiff {
int sum;
int diff;
};
struct SumDiff calculate(int a, int b) {
struct SumDiff result;
result.sum = a + b;
result.diff = a - b;
return result;
}
//Function returning multiple values (with multi-value return, using Emscripten)
void calculateMV(int a, int b, int* sum, int* diff) {
*sum = a + b;
*diff = a - b;
}
// or, directly return from the multi-value function
// Example using multiple return from a function
int add(int a, int b) {
return a + b;
}
int subtract(int a, int b) {
return a - b;
}
int main() {
int a = 10, b = 5;
int sum = 0, diff = 0;
calculateMV(a, b, &sum, &diff);
printf("Sum: %d, Difference: %d\n", sum, diff);
int result_add = add(a,b);
int result_sub = subtract(a,b);
printf("add result: %d, subtract result: %d\n", result_add, result_sub);
return 0;
}
(๋ค์ค ๊ฐ ๋ฐํ ์ง์์ ํ์ฑํํ๊ธฐ ์ํด ์ ์ ํ ํ๋๊ทธ๋ฅผ ์ฌ์ฉํ์ฌ) Emscripten์ผ๋ก ์ปดํ์ผํ๋ฉด ์ปดํ์ผ๋ฌ๋ ์ฝ๋๋ฅผ ์ต์ ํํ์ฌ ๋ค์ค ๊ฐ ๋ฐํ ๋ฉ์ปค๋์ฆ์ ์ฌ์ฉํ์ฌ ๋ณด๋ค ํจ์จ์ ์ธ Wasm ์ฝ๋๋ฅผ ์์ฑํฉ๋๋ค.
์ค์ ์์ ๋ฐ ๊ธ๋ก๋ฒ ์ ํ๋ฆฌ์ผ์ด์
๋ค์ค ๊ฐ ๋ฐํ์ ์ฌ๋ฌ ๊ด๋ จ ๊ฐ์ ๋ฐํํด์ผ ํ๋ ์๋๋ฆฌ์ค์์ ํนํ ์ ์ฉํฉ๋๋ค. ๋ค์ ์๋ฅผ ๊ณ ๋ คํ์ญ์์ค.
- ์ด๋ฏธ์ง ์ฒ๋ฆฌ: ์ฒ๋ฆฌ๋ ์ด๋ฏธ์ง ๋ฐ์ดํฐ์ ๋ฉํ๋ฐ์ดํฐ(์: ์ด๋ฏธ์ง ๋๋น, ๋์ด ๋ฐ ํ์)๋ฅผ ๋ชจ๋ ๋ฐํํ๋ ํจ์. ์ด๋ ๋งค์ฐ ํจ์จ์ ์ธ ์น ๊ธฐ๋ฐ ์ด๋ฏธ์ง ํธ์ง ๋๊ตฌ๋ฅผ ๋ง๋๋ ๋ฐ ํนํ ์ ์ฉํฉ๋๋ค.
- ๊ฒ์ ๊ฐ๋ฐ: ์ถฉ๋ ํ ๊ฒ์ ๊ฐ์ฒด์ ์๋ก์ด ์์น์ ์๋๋ฅผ ๋ชจ๋ ๋ฐํํ๋ ๊ฒ๊ณผ ๊ฐ์ ๋ฌผ๋ฆฌ ์์ง๊ณผ ๊ด๋ จ๋ ๊ณ์ฐ. ์ด ์ต์ ํ๋ ์ ์ธ๊ณ ํ๋ซํผ์์ ๋ถ๋๋ฝ๊ณ ๋ฐ์์ฑ์ด ๋ฐ์ด๋ ๊ฒ์ํ๋ ์ด์ ๋งค์ฐ ์ค์ํฉ๋๋ค.
- ๊ณผํ ์ปดํจํ : ํ๋ ฌ ์ธ์ ๋ถํด ๊ฒฐ๊ณผ ๋๋ ํต๊ณ ๋ถ์ ๊ฒฐ๊ณผ์ ๊ฐ์ด ์ฌ๋ฌ ๊ฒฐ๊ณผ๋ฅผ ๋ฐํํ๋ ์ซ์ ์๊ณ ๋ฆฌ์ฆ. ์ด๋ ์ ์ธ๊ณ ์ฐ๊ตฌ์๋ค์ด ์ฌ์ฉํ๋ ์ ํ๋ฆฌ์ผ์ด์ ์ ์ฑ๋ฅ์ ํฅ์์ํต๋๋ค.
- ๊ตฌ๋ฌธ ๋ถ์: ๋ฐ์ดํฐ ํ์์ ๊ตฌ๋ฌธ ๋ถ์ํ๋ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ ๊ตฌ๋ฌธ ๋ถ์ ์ฑ๊ณต ๋๋ ์คํจ์ ๋ํ ํ์์ ํจ๊ป ๊ตฌ๋ฌธ ๋ถ์๋ ๊ฐ์ ๋ฐํํด์ผ ํ๋ ๊ฒฝ์ฐ๊ฐ ๋ง์ต๋๋ค. ์ด๋ ๋ชจ๋ ๋๋ฅ์ ๊ฐ๋ฐ์์๊ฒ ์ํฅ์ ๋ฏธ์นฉ๋๋ค.
- ์ฌ๋ฌด ๋ชจ๋ธ๋ง: ๋ฐ๋, ๋ด์, ๋์ฟ์ ๊ฐ์ ๊ธ์ต ํ๋ธ์ ์ ๋ฌธ๊ฐ๋ค์ด ์ฌ์ฉํ๋ ์ฌ๋ฌด ๋ชจ๋ธ์์ ํ์ฌ ๊ฐ์น, ๋ฏธ๋ ๊ฐ์น ๋ฐ ๋ด๋ถ ์์ต๋ฅ ์ ๋์์ ๊ณ์ฐํฉ๋๋ค.
์: Rust ๋ฐ Wasm์ ์ฌ์ฉํ ์ด๋ฏธ์ง ์ฒ๋ฆฌ
Rust ํจ์๊ฐ ๊ฐ๋จํ ์ด๋ฏธ์ง ํํฐ๋ฅผ ์ํํ๊ณ ์ ์ด๋ฏธ์ง ๋ฐ์ดํฐ์ ํด๋น ์ฐจ์์ ๋ฐํํด์ผ ํ๋ค๊ณ ๊ฐ์ ํด ๋ณด๊ฒ ์ต๋๋ค. ๋ค์ค ๊ฐ ๋ฐํ์ ์ฌ์ฉํ๋ฉด ์ด๋ฅผ ํจ์จ์ ์ผ๋ก ์ฒ๋ฆฌํ ์ ์์ต๋๋ค.
// Rust code using the image crate and multi-value return.
// The image crate is a popular choice among rust developers.
use image::{GenericImageView, DynamicImage};
// Define a struct (optional) to return the data
struct ImageResult {
data: Vec<u8>,
width: u32,
height: u32,
}
#[no_mangle]
pub extern "C" fn apply_grayscale(image_data: *const u8, width: u32, height: u32) -> (*mut u8, u32, u32) {
// Convert raw image data
let image = image::load_from_memory_with_format(unsafe { std::slice::from_raw_parts(image_data, (width * height * 4) as usize)}, image::ImageFormat::Png).unwrap();
// Apply grayscale
let gray_image = image.to_luma8();
// Get image data as bytes
let mut data = gray_image.into_raw();
// Return data as a raw pointer
let ptr = data.as_mut_ptr();
(ptr, width, height)
}
์ด ์์์ `apply_grayscale` ํจ์๋ ์ด๋ฏธ์ง ๋ฐ์ดํฐ์ ์ฐจ์์ ์ ๋ ฅ์ผ๋ก ์ฌ์ฉํฉ๋๋ค. ๊ทธ๋ฐ ๋ค์ ์ด๋ฏธ์ง๋ฅผ ์ฒ๋ฆฌํ๊ณ ํ์์กฐ๋ก ๋ณํํ ๋ค์ ์ฒ๋ฆฌ๋ ๋ฐ์ดํฐ, ๋๋น ๋ฐ ๋์ด๋ฅผ ์ง์ ๋ฐํํ์ฌ ๋ณ๋์ ํ ๋น์ด๋ ๊ตฌ์กฐ์ฒด๊ฐ ํ์ํ์ง ์์ต๋๋ค. ์ด๋ฌํ ๊ฐ์ ๋ ์ฑ๋ฅ์ ํด๋ผ์ด์ธํธ ์ธก(๋ธ๋ผ์ฐ์ )๊ณผ ์๋ฒ ์ธก(์ด๋ฏธ์ง ์ฝํ ์ธ ๋ฅผ ์ ๊ณตํ๋ ์น ์๋ฒ์ ์ฌ์ฉ๋๋ ๊ฒฝ์ฐ)์์ ๋๋๋ฌ์ง๋๋ค.
์ฑ๋ฅ ๋ฒค์น๋งํน ๋ฐ ์ค์ ์ํฅ
๋ค์ค ๊ฐ ๋ฐํ์ ์ด์ ์ ๋ฒค์น๋งํฌ๋ฅผ ํตํด ๊ฐ์ฅ ์ ์ ๋ํ๋ฉ๋๋ค. ์ฑ๋ฅ ํฅ์์ ์ ํ๋ฆฌ์ผ์ด์ ์ ๋ฐ๋ผ ๋ค๋ฅด์ง๋ง ํ ์คํธ์์๋ ์ผ๋ฐ์ ์ผ๋ก ๋ค์๊ณผ ๊ฐ์ ์ถ์ธ๋ฅผ ๋ณด์ฌ์ค๋๋ค.
- ๋ฉ๋ชจ๋ฆฌ ํ ๋น ๊ฐ์: `malloc` ๋๋ ์ ์ฌํ ๋ฉ๋ชจ๋ฆฌ ํ ๋น์์ ๋ํ ํธ์ถ ํ์๊ฐ ์ค์ด๋ญ๋๋ค.
- ๋ ๋น ๋ฅธ ์คํ ์๊ฐ: ์ฌ๋ฌ ๊ฐ์ด ๋ฐํ๋๋ ํจ์์์ ์๋นํ ์๋ ํฅ์.
- ํฅ์๋ ์๋ต์ฑ: ๋ ๋น ๋ฅธ ๊ณ์ฐ์ ์ด์ ์ ๋๋ฆฌ๋ ์ฌ์ฉ์ ์ธํฐํ์ด์ค๊ฐ ๋ ๋นจ๋ผ์ง ๊ฒ์ ๋๋ค.
๋ฒค์น๋งํน ๊ธฐ์ :
- ํ์ค ๋ฒค์น๋งํน ๋๊ตฌ: `wasm-bench` ๋๋ ์ฌ์ฉ์ ์ง์ ๋ฒค์น๋งํน ๋๊ตฌ์ ๊ฐ์ ๋๊ตฌ๋ฅผ ์ฌ์ฉํ์ฌ ์คํ ์๊ฐ์ ์ธก์ ํฉ๋๋ค.
- ๊ตฌํ ๋น๊ต: ๋ค์ค ๊ฐ ๋ฐํ์ ์ฌ์ฉํ๋ ์ฝ๋์ ์ฑ๋ฅ๊ณผ ๊ตฌ์กฐ์ฒด๋ฅผ ๋ฐํํ๊ฑฐ๋ out ๋งค๊ฐ๋ณ์๋ฅผ ์ฌ์ฉํ๋ ์ฝ๋์ ์ฑ๋ฅ์ ๋น๊ตํฉ๋๋ค.
- ์ค์ ์๋๋ฆฌ์ค: ์ต์ ํ์ ์ ์ฒด ์ํฅ์ ์ป๊ธฐ ์ํด ์ค์ ์ฌ์ฉ ์๋๋ฆฌ์ค์์ ์ ํ๋ฆฌ์ผ์ด์ ์ ํ ์คํธํฉ๋๋ค.
์ค์ ์์ : Google, Mozilla ๋ฑ๊ณผ ๊ฐ์ ํ์ฌ๋ Wasm์์ ๋ค์ค ๊ฐ ๋ฐํ์ ํ์ฉํ์ฌ ์น ์ ํ๋ฆฌ์ผ์ด์ ์์ ์๋นํ ๊ฐ์ ์ ๋ณด์์ต๋๋ค. ์ด๋ฌํ ์ฑ๋ฅ ํฅ์์ ํนํ ์ธํฐ๋ท ์ฐ๊ฒฐ ์๋๊ฐ ๋๋ฆฐ ์ง์ญ์ ์ฌ์ฉ์์๊ฒ ๋ ๋์ ์ฌ์ฉ์ ๊ฒฝํ์ ์ ๊ณตํฉ๋๋ค.
๊ณผ์ ์ ๋ฏธ๋ ๋ํฅ
๋ค์ค ๊ฐ ๋ฐํ์ ์๋นํ ๊ฐ์ ์ ์ ๊ณตํ์ง๋ง ๊ฐ์ ๋ฐ ๋ฏธ๋ ๊ฐ๋ฐ์ ์ํ ์์ญ์ด ์ฌ์ ํ ์์ต๋๋ค.
- ์ปดํ์ผ๋ฌ ์ง์: Wasm์ผ๋ก ์ปดํ์ผ๋๋ ๋ชจ๋ ์ธ์ด์์ ๋ค์ค ๊ฐ ๋ฐํ์ ์ํ ์ปดํ์ผ๋ฌ ์ต์ ํ ๋ฐ ์ฝ๋ ์์ฑ ๊ฐ์ .
- ๋๋ฒ๊น ๋๊ตฌ: ๋ค์ค ๊ฐ ๋ฐํ ์ฝ๋๋ฅผ ๋ ์ ์ง์ํ๋๋ก ๋๋ฒ๊น ๋๊ตฌ๋ฅผ ๊ฐํํฉ๋๋ค. ์ฌ๊ธฐ์๋ ๋๋ฒ๊น ์ถ๋ ฅ๊ณผ ๋ฐํ๋ ๊ฐ์ ์ฝ๊ฒ ๊ฒ์ฌํ๋ ๊ธฐ๋ฅ์ด ํฌํจ๋ฉ๋๋ค.
- ํ์คํ ๋ฐ ์ฑํ: ๋ชจ๋ ํ๊ฒฝ์์ ์ ์ญ์ ์ผ๋ก ํธํ์ฑ์ ๋ณด์ฅํ๊ธฐ ์ํด ๋ค์ํ Wasm ๋ฐํ์ ๋ฐ ๋ธ๋ผ์ฐ์ ์์ ๋ค์ค ๊ฐ ๋ฐํ์ ํ์คํํ๊ณ ์์ ํ ๊ตฌํํ๊ธฐ ์ํ ์ง์์ ์ธ ์์ .
๋ฏธ๋ ๋ํฅ:
- ๋ค๋ฅธ Wasm ๊ธฐ๋ฅ๊ณผ์ ํตํฉ: SIMD ๋ช ๋ น๊ณผ ๊ฐ์ Wasm์ ๋ค๋ฅธ ์ฑ๋ฅ ํฅ์ ๊ธฐ๋ฅ๊ณผ ๋ค์ค ๊ฐ ๋ฐํ์ ํตํฉํ๋ฉด ํจ์ฌ ๋ ํฐ ํจ์จ์ฑ์ ์ป์ ์ ์์ต๋๋ค.
- WebAssembly System Interface (WASI): ์๋ฒ ์ธก ์ ํ๋ฆฌ์ผ์ด์ ์ ์ฉ์ดํ๊ฒ ํ๊ธฐ ์ํด WASI ์์ฝ์์คํ ๋ด์์ ๋ค์ค ๊ฐ ๋ฐํ์ ๋ํ ์์ ํ ์ง์.
- ๋๊ตฌ ๋ฐ์ : ๊ฐ๋ฐ์๊ฐ ๋ค์ค ๊ฐ ๋ฐํ ์ฝ๋๋ฅผ ํจ๊ณผ์ ์ผ๋ก ํ์ฉํ๊ณ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ ๋ฐ ๋์์ด ๋๋ ๋ณด๋ค ์ ๊ตํ ๋๋ฒ๊ฑฐ ๋ฐ ํ๋กํ์ผ๋ฌ์ ๊ฐ์ ๋ ๋์ ๋๊ตฌ ๊ฐ๋ฐ.
๊ฒฐ๋ก : ๊ธ๋ก๋ฒ ์ฒญ์ค์ ์ํ ํจ์ ์ธํฐํ์ด์ค ๊ฐ์
WebAssembly์ ๋ค์ค ๊ฐ ๋ฐํ ๊ธฐ๋ฅ์ ์น ์ ํ๋ฆฌ์ผ์ด์ ์ ์ฑ๋ฅ๊ณผ ํจ์จ์ฑ์ ํฅ์์ํค๋ ๋ฐ ์ค์ํ ๋จ๊ณ์ ๋๋ค. ํจ์๊ฐ ์ฌ๋ฌ ๊ฐ์ ์ง์ ๋ฐํํ ์ ์๋๋ก ํจ์ผ๋ก์จ ๊ฐ๋ฐ์๋ ๋ ๋น ๋ฅด๊ณ ์คํ๋๋ ๋ ๊น๋ํ๊ณ ์ต์ ํ๋ ์ฝ๋๋ฅผ ์์ฑํ ์ ์์ต๋๋ค. ์ด์ ์ผ๋ก๋ ๋ฉ๋ชจ๋ฆฌ ํ ๋น ๊ฐ์, ์คํ ์๋ ํฅ์ ๋ฐ ์ฝ๋ ๊ฐ์ํ๊ฐ ์์ต๋๋ค. ์ด๋ ์ ์ธ๊ณ ์ฅ์น ๋ฐ ๋คํธ์ํฌ์์ ์น ์ฑ ์๋ต์ฑ๊ณผ ์ฑ๋ฅ์ ํฅ์์ํค๊ธฐ ๋๋ฌธ์ ๊ธ๋ก๋ฒ ์ฒญ์ค์๊ฒ ํนํ ์ ์ฉํฉ๋๋ค.
์ปดํ์ผ๋ฌ ์ง์, ํ์คํ ๋ฐ ๋ค๋ฅธ Wasm ๊ธฐ๋ฅ๊ณผ์ ํตํฉ์ด ์ง์์ ์ผ๋ก ๋ฐ์ ํจ์ ๋ฐ๋ผ ๋ค์ค ๊ฐ ๋ฐํ์ Wasm ์งํ์์ ๊ณ์ ์ค์ํ ์ญํ ์ ํ ๊ฒ์ ๋๋ค. ๊ฐ๋ฐ์๋ ์ด ๊ธฐ๋ฅ์ ์ฑํํด์ผ ํฉ๋๋ค. ์ด ๊ธฐ๋ฅ์ ๊ธ๋ก๋ฒ ์ฒญ์ค์๊ฒ ๋ ๋์ ์ฌ์ฉ์ ๊ฒฝํ์ ์ ๊ณตํ๋ ๋ ๋น ๋ฅด๊ณ ํจ์จ์ ์ธ ์ ํ๋ฆฌ์ผ์ด์ ์ ๋ง๋๋ ๊ฒฝ๋ก๋ฅผ ์ ๊ณตํ๊ธฐ ๋๋ฌธ์ ๋๋ค.
๋ค์ค ๊ฐ ๋ฐํ์ ์ดํดํ๊ณ ์ฑํํจ์ผ๋ก์จ ๊ฐ๋ฐ์๋ WebAssembly ์ ํ๋ฆฌ์ผ์ด์ ์ ์๋ก์ด ์์ค์ ์ฑ๋ฅ์ ์ ๊ธ ํด์ ํ์ฌ ์ ์ธ๊ณ์ ์ผ๋ก ๋ ๋์ ์ฌ์ฉ์ ๊ฒฝํ์ ์ ๊ณตํ ์ ์์ต๋๋ค.
์ด ๊ธฐ์ ์ ๋ค์๊ณผ ๊ฐ์ ๊ณณ์์ ์ ์ธ๊ณ์ ์ผ๋ก ์ฑํ๋๊ณ ์์ต๋๋ค.
- ๋ถ๋ฏธ, Google ๋ฐ Microsoft์ ๊ฐ์ ํ์ฌ๊ฐ ๋ง๋ํ ํฌ์๋ฅผ ํ๊ณ ์์ต๋๋ค.
- ์ ๋ฝ, ์ ๋ฝ ์ฐํฉ์ Wasm์ ์ฌ์ฉํ๋ ์ด๋์ ํฐ๋ธ๋ฅผ ์ง์ํฉ๋๋ค.
- ์์์, ์ค๊ตญ, ์ธ๋, ์ผ๋ณธ์์ ์น ๋ฐ ๋ชจ๋ฐ์ผ ์ ํ๋ฆฌ์ผ์ด์ ๋ชจ๋์ ๋ํด ๋น ๋ฅด๊ฒ ์ฑํ๋๊ณ ์์ต๋๋ค.
- ๋จ๋ฏธ, Wasm์ ์ฑํํ๋ ๊ฐ๋ฐ์ ์๊ฐ ์ฆ๊ฐํ๊ณ ์์ต๋๋ค.
- ์ํ๋ฆฌ์นด, Wasm์ ๋ชจ๋ฐ์ผ ์ฐ์ ๊ฐ๋ฐ๋ก ์ง์ถํ๊ณ ์์ต๋๋ค.
- ์ค์ธ์๋์, ํธ์ฃผ์ ๋ด์ง๋๋๋ Wasm ์ปค๋ฎค๋ํฐ์ ์ ๊ทน์ ์ผ๋ก ์ฐธ์ฌํ๊ณ ์์ต๋๋ค.
์ด๋ฌํ ์ ์ธ๊ณ์ ์ธ ์ฑํ์ WebAssembly์ ์ค์์ฑ, ํนํ ๋ค์ํ ์ฅ์น ๋ฐ ๋คํธ์ํฌ์์ ๊ณ ์ฑ๋ฅ์ ์ ๊ณตํ๋ ๋ฅ๋ ฅ์ ๋ณด์ฌ์ค๋๋ค.